hal_trace.h

Go to the documentation of this file.

#ifndef HAL_TRACE_H
#define HAL_TRACE_H
 
/* ****************************** HAL TRACE API declaration ******************************** */
/* ***************************************************************************************** */
 
/* ***************************************************************************************** */
/* ***************************************************************************************** */
 
/* ********************************* hal_set_trace_mode ************************************ */
/* ***************************************************************************************** */
extern KER_BOOL hal_set_trace_mode(KER_CTX_PARAM KER_BYTE btTraceMode);
 
/* ********************************* hal_get_trace_mode ************************************ */
/* ***************************************************************************************** */
extern KER_BYTE hal_get_trace_mode(KER_CTX_SINGLE_PARAM);
 
/* ********************************** hal_trace_string ************************************* */
/* ***************************************************************************************** */
extern KER_BOOL hal_trace_string(KER_CTX_PARAM const KER_CHAR* pchString);
 
/* ********************************** hal_trace_buffer ************************************* */
/* ***************************************************************************************** */
extern KER_BOOL hal_trace_buffer(KER_CTX_PARAM const KER_BYTE* pbtDataBuffer, KER_INT16U usDataBufferSize);
 
/* *********************************** hal_trace_time ************************************** */
/* ***************************************************************************************** */
extern KER_BOOL hal_trace_time(KER_CTX_SINGLE_PARAM);
 
/* ********************************* hal_keep_trace_time *********************************** */
/* ***************************************************************************************** */
extern KER_BOOL hal_keep_trace_time(KER_CTX_PARAM KER_BYTE* pbtTimeBuffer, KER_INT16U* pusTimeBufferSize);
 
/* *********************************** hal_trace_flush ************************************* */
/* ***************************************************************************************** */
extern KER_BOOL hal_trace_flush(KER_CTX_SINGLE_PARAM);
 
/* ************************************** hal_error **************************************** */
/* ***************************************************************************************** */
extern KER_BOOL hal_error(KER_CTX_PARAM KER_INT16U usTraceLevel, KER_RES resErrCode, const KER_CHAR* pchErrorText);
 
/* *********************************** trace marcos **************************************** */
 /* ***************************************************************************************** */
#define KER_TRACE_MODE_STD                  0x00    
#define KER_TRACE_MODE_SENS                 0x01    
#define KER_TRACE_APDU_REQ_TAB          "              "                        
#define KER_TRACE_APDU_INT_REQ_TAB  "                   Int"        
#define KER_TRACE_APDU_INT_RESP_TAB "                     Int"  
#define KER_TRACE_APDU_RESP_TAB         "                "                  
#define KER_TRACE_COMB_TAB                  "  "                                                
/* ***************************************************************************************** */
 
/* ***************************************************************************************** */
/*                               Use this macro to include trace                             */
/* ***************************************************************************************** */
#define KER_DBG_EX(IgnoreLevel,ErrLevel) ((KER_DEBUG == KER_TRUE) && ((KER_DEBUG_LEVEL >= ErrLevel) || (KER_DEBUG_ALL == KER_TRUE) || (IgnoreLevel == KER_TRUE))) 
#define KER_DBG(ErrLevel) KER_DBG_EX(KER_FALSE,ErrLevel) 
#define KER_INFO KER_DBG_EX(KER_TRUE,0) 
/* ***************************************************************************************** */
/*                                Use this macro to trace eol                                */
/* ***************************************************************************************** */
#ifndef KER_TRACE_EOL   /* If Custom trace not defined, then use default */
#define KER_TRACE_EOL "\r\n"    
#endif /* KER_TRACE_EOL */
 
/* ***************************************************************************************** */
/*                          Use this macro to trace comment headers                          */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_HDR_NO_TIME /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
/* default trace comment w/o time macro */
#define KER_COMMENT_HDR_NO_TIME(comment) \
do \
{   \
    KER_CHAR ar_chHeader[] = "****************************************************************";    \
    hal_trace_string(KER_CTX KER_TRACE_EOL); \
    if ((sizeof(comment) + 12) >= sizeof(ar_chHeader))  \
    {   \
        hal_trace_string(KER_CTX "***** "); \
        hal_trace_string(KER_CTX comment);  \
        hal_trace_string(KER_CTX " *****"); \
    }   \
    else \
    {   \
        KER_BYTE btOffset = (sizeof(ar_chHeader) - (sizeof(comment) + 2)) / 2;  \
        ar_chHeader[btOffset] = ' ';    \
        KER_MEM_ADD(ar_chHeader, sizeof(ar_chHeader), btOffset + 1, comment, sizeof(comment) - 1);  \
        ar_chHeader[btOffset + sizeof(comment)] = ' ';  \
        hal_trace_string(KER_CTX ar_chHeader); \
    }   \
    hal_trace_string(KER_CTX KER_TRACE_EOL); \
}   \
while(0)
#else
/* empty trace comment w/o time macro */
#define KER_COMMENT_HDR_NO_TIME(commnet)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_HDR_NO_TIME */
 
/* ***************************************************************************************** */
/*                          Use this macro to trace comment headers                          */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_HDR_EX  /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
/* default trace comment macro */
#define KER_COMMENT_HDR_EX(comment) \
do \
{   \
    KER_COMMENT_HDR_NO_TIME(comment);   \
    hal_trace_time(KER_CTX_SINGLE); \
    hal_trace_string(KER_CTX KER_TRACE_EOL KER_TRACE_EOL); \
}   \
while(0)
#else
/* empty trace comment macro */
#define KER_COMMENT_HDR_EX(commnet)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_HDR_EX */
 
/* ***************************************************************************************** */
/*                          Use this macro to trace comment footers                          */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_FTR_EX  /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
/* default trace comment macro */
#define KER_COMMENT_FTR_EX(comment) \
do \
{   \
    KER_CHAR ar_chHeader[] = "****************************************************************";    \
    if ((sizeof(comment) + 12) >= sizeof(ar_chHeader))  \
    {   \
        hal_trace_string(KER_CTX "*end* "); \
        hal_trace_string(KER_CTX comment);  \
        hal_trace_string(KER_CTX " *end*"); \
    }   \
    else \
    {   \
        KER_BYTE btOffset = (sizeof(ar_chHeader) - (sizeof(comment) + 12)) / 2; \
        KER_MEM_ADD(ar_chHeader, sizeof(ar_chHeader), btOffset, "*end* ", 6);   \
        KER_MEM_ADD(ar_chHeader, sizeof(ar_chHeader), btOffset + 6, comment, sizeof(comment) - 1);  \
        KER_MEM_ADD(ar_chHeader, sizeof(ar_chHeader), btOffset + 6 + sizeof(comment) - 1, " *end*", 6); \
        hal_trace_string(KER_CTX ar_chHeader); \
    }   \
    hal_trace_string(KER_CTX KER_TRACE_EOL KER_TRACE_EOL); \
    hal_trace_flush(KER_CTX_SINGLE); \
}   \
while(0)
#else
/* empty trace comment macro */
#define KER_COMMENT_FTR_EX()
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_FTR_EX */
 
/* ***************************************************************************************** */
/*                     Use this macro to define default trace header text                    */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_HDR_TEXT    /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_COMMENT_HDR_TEXT(text) const KER_CHAR const_ch___CommentHeader[] = text 
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_HDR_TEXT */
 
/* ***************************************************************************************** */
/*                        Use this macro to define default trace header                      */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_HDR /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_COMMENT_HDR(text) KER_COMMENT_HDR_TEXT(text); KER_COMMENT_HDR_EX(const_ch___CommentHeader)  
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_HDR */
 
/* ***************************************************************************************** */
/*                     Use this macro to define default trace footer text                    */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_FTR /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_COMMENT_FTR() KER_COMMENT_FTR_EX(const_ch___CommentHeader)  
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_FTR */
 
/* ***************************************************************************************** */
/*                             Use this macro to trace text w/o eol                          */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_TEXT    /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
/* default trace text macro */
#define KER_COMMENT_TEXT(text) hal_trace_string(KER_CTX text)
#else
/* empty trace text macro */
#define KER_COMMENT_TEXT(text)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_TEXT */
 
/* ***************************************************************************************** */
/*                              Use this macro to trace comments                             */
/* ***************************************************************************************** */
#ifndef KER_COMMENT /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
/* default trace comment macro */
#define KER_COMMENT(comment) \
do \
{   \
    hal_trace_string(KER_CTX comment);  \
    hal_trace_string(KER_CTX KER_TRACE_EOL);    \
}   \
while(0)
#else
/* empty trace comment macro */
#define KER_COMMENT(commnet)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT */
 
/* ***************************************************************************************** */
/*                    Use this macro to define default trace test mode text                  */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_TEST_MODE   /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_COMMENT_TEST_MODE() KER_COMMENT("########################## TEST MODE! ##########################") 
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_TEST_MODE */
 
/* ***************************************************************************************** */
/*                Use this macro to define default trace test mode disabled text             */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_TEST_MODE_DISABLED  /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_COMMENT_TEST_MODE_DISABLED() KER_COMMENT("###################### TEST MODE DISABLED ######################")    
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_TEST_MODE_DISABLED */
 
/* ***************************************************************************************** */
/*                                Use this macro to trace time                               */
/* ***************************************************************************************** */
#ifndef KER_TRACE_TIME  /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
/* default trace comment macro */
#define KER_TRACE_TIME() hal_trace_time(KER_CTX_SINGLE)
#else
/* empty trace comment macro */
#define KER_TRACE_TIME()
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_TRACE_TIME */
 
/* ***************************************************************************************** */
/*                       Use this macro to trace comments with hex data                      */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_HEX /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
/* default trace comment with hex data macro */
#define KER_COMMENT_HEX(comment_start, buff, buff_len, comment_end) \
do \
{   \
    hal_trace_string(KER_CTX comment_start);    \
    hal_trace_buffer(KER_CTX buff, buff_len);   \
    hal_trace_string(KER_CTX comment_end);  \
}   \
while(0)
#else
/* empty trace comment macro */
#define KER_COMMENT_HEX(comment_start, buff, buff_len, comment_end)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_HEX */
 
/* ***************************************************************************************** */
/*                       Use this macro to fill text string with hex data                    */
/* ***************************************************************************************** */
#ifndef KER_TEXT_HEX    /* If Custom trace not defined, then use default */
#define KER_TEXT_HEX(dest, dest_len, buff, buff_len) \
do \
{   \
    KER_INT16U usI; \
    KER_CHAR ar_chBuff[8];  \
    KER_MEM_SET(dest, dest_len, 0, dest_len);   \
    for (usI = 0; usI < (KER_BYTE)(buff_len); usI++)    \
    {   \
        hal_sprintf(KER_CTX ar_chBuff, sizeof(ar_chBuff), "%02X", (KER_NATIVE_UINT)buff[usI]);  \
        KER_MEM_ADD(dest, dest_len, usI * 2, ar_chBuff, 2); \
    }   \
}   \
while(0)
#endif /* KER_TEXT_HEX */
 
/* ***************************************************************************************** */
/*                   Use this macro to trace comments with ansi string data                  */
/* ***************************************************************************************** */
#ifndef KER_COMMENT_STR /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
/* default trace comment with ansi string data buffer macro */
#define KER_COMMENT_STR(comment_start, buff, buff_len, comment_end) \
do \
{   \
    KER_CHAR ar_ch___Buffer[8]; \
    KER_INT16U us___Pos;    \
    hal_trace_string(KER_CTX comment_start);    \
    for (us___Pos = 0; us___Pos < (buff_len); us___Pos++)   \
    {   \
        if ((buff)[us___Pos] >= 0x20)   \
            hal_sprintf(KER_CTX ar_ch___Buffer, sizeof(ar_ch___Buffer), "%c", (KER_CHAR)((buff)[us___Pos])); \
        else \
            hal_sprintf(KER_CTX ar_ch___Buffer, sizeof(ar_ch___Buffer), "[%02X]", (KER_NATIVE_UINT)((buff)[us___Pos])); \
        hal_trace_string(KER_CTX ar_ch___Buffer);   \
    }   \
    hal_trace_string(KER_CTX comment_end);  \
}   \
while(0)
#else
/* empty trace comment macro */
#define KER_COMMENT_STR(comment_start, buff, buff_len, comment_end)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_COMMENT_STR */
 
/* ***************************************************************************************** */
/*        Use this macro to declare one buffer for all trace error calls per function        */
/* ***************************************************************************************** */
#ifndef KER_TRACE_ERR_BUF   /* If Custom trace not defined, then use default */
#define KER_TRACE_ERR_BUF KER_CHAR ar_ch___ErrBuffer[32];
#endif
 
/* ***************************************************************************************** */
/* Use this macro to declare one buffer for all trace error calls per function (debug only)  */
/* ***************************************************************************************** */
#ifndef KER_TRACE_SYS_ERR_BUF   /* If Custom trace not defined, then use default */
    #ifdef _DEBUG
        #define KER_TRACE_SYS_ERR_BUF KER_CHAR ar_ch___ErrBuffer[32];
    #else
        #define KER_TRACE_SYS_ERR_BUF
    #endif // _DEBUG
#endif
 
/* ***************************************************************************************** */
/*        Use this macro to declare one buffer for all trace info calls per function         */
/* ***************************************************************************************** */
#ifndef KER_TRACE_BUF   /* If Custom trace not defined, then use default */
#define KER_TRACE_BUF(Size) KER_CHAR ar_ch___InfBuffer[Size];
#endif
 
/* ***************************************************************************************** */
/*                 Use this macro to reset common trace buffer for PCI SSS.                  */
/* ***************************************************************************************** */
#ifndef KER_RESET_TRACE_BUF /* If Custom trace not defined, then use default */
#define KER_RESET_TRACE_BUF KER_MEM_SET(ar_ch___InfBuffer, sizeof(ar_ch___InfBuffer), 0, sizeof(ar_ch___InfBuffer));
#endif
 
/* ***************************************************************************************** */
/*                               Use this macro to trace errors                              */
/* ***************************************************************************************** */
#ifndef KER_ERROR   /* If Custom trace not defined, then use default */
    #ifdef _DEBUG
    #define KER_ERROR(err_code,trace_level,comment) \
        do \
        { \
            if ((KER_DEBUG == KER_TRUE) && (trace_level <= KER_DEBUG_LEVEL)) \
            { \
                /* trace comment firstly*/ \
                if (comment != KER_NULL) \
                {   \
                    /* trace to erl */  \
                    hal_error(KER_CTX trace_level,  err_code, comment); \
                    /* trace to emv */  \
                    hal_trace_string(KER_CTX comment); \
                }   \
                /* trace error */ \
                hal_sprintf(KER_CTX ar_ch___ErrBuffer, sizeof(ar_ch___ErrBuffer), "  Error: %08lX ", (KER_NATIVE_ULONG)(err_code)); \
                hal_trace_string(KER_CTX ar_ch___ErrBuffer); \
                hal_trace_string(KER_CTX __FILE__); \
                hal_sprintf(KER_CTX ar_ch___ErrBuffer, sizeof(ar_ch___ErrBuffer), " line:%lu" KER_TRACE_EOL, (KER_NATIVE_ULONG)__LINE__); \
                hal_trace_string(KER_CTX ar_ch___ErrBuffer); \
            } \
        } \
        while(0)
    #else /* _DEBUG */
        #define KER_ERROR(err_code,trace_level,comment) \
        do \
        { \
            if ((KER_DEBUG == KER_TRUE) && (trace_level <= KER_DEBUG_LEVEL)) \
            { \
                /* trace comment firstly*/ \
                if (comment != KER_NULL) \
                {   \
                    /* trace to erl */  \
                    hal_error(KER_CTX trace_level,  err_code, comment); \
                    /* trace to emv */  \
                    hal_trace_string(KER_CTX comment); \
                }   \
                /* trace error */ \
                hal_sprintf(KER_CTX ar_ch___ErrBuffer, sizeof(ar_ch___ErrBuffer), "  Error: %08lX" KER_TRACE_EOL, (KER_NATIVE_ULONG)(err_code));    \
                /* trace to emv */  \
                hal_trace_string(KER_CTX ar_ch___ErrBuffer); \
            } \
        } \
        while(0)
    #endif  /* _DEBUG */
#endif /* KER_ERROR */
 
/* ***************************************************************************************** */
/*                  Use this macro to trace system errors (to erl only)                      */
/* ***************************************************************************************** */
#ifndef KER_SYS_ERROR   /* If Custom trace not defined, then use default */
    #ifdef _DEBUG
        #define KER_SYS_ERROR(err_code,trace_level,comment) \
        do \
        { \
            /* trace */ \
            if (comment != KER_NULL) \
            { \
                /* trace error */ \
                hal_error(KER_CTX trace_level,  err_code, comment); \
            } \
            hal_sprintf(KER_CTX ar_ch___ErrBuffer, sizeof(ar_ch___ErrBuffer), "line:%lu file: ", (KER_NATIVE_ULONG)__LINE__); \
            hal_error(KER_CTX trace_level,  err_code, ar_ch___ErrBuffer); \
            hal_error(KER_CTX trace_level,  err_code, __FILE__); \
        } \
        while(0)
    #else   /* _DEBUG */
        #define KER_SYS_ERROR(err_code,trace_level,comment) hal_error(KER_CTX trace_level,  err_code, comment)
    #endif  /* _DEBUG */
#endif /* KER_SYS_ERROR */
 
/* ***************************************************************************************** */
/*                   Use this macro to trace system info (to erl only)                       */
/* ***************************************************************************************** */
#ifndef KER_SYS_INFO    /* If Custom trace not defined, then use default */
#define KER_SYS_INFO(err_code,trace_level,comment) hal_error(KER_CTX trace_level, err_code, comment)
#endif /* KER_SYS_INFO */
 
/* ***************************************************************************************** */
/*                          Use this macro to trace tag not found                            */
/* ***************************************************************************************** */
#ifndef KER_TRACE_TAG_NOT_FOUND /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TAG_INFO))
#define KER_TRACE_TAG_NOT_FOUND(tag, tag_length) \
    do \
    {   \
        hal_trace_string(KER_CTX "Tag [");  \
        hal_trace_buffer(KER_CTX tag, tag_length);  \
        hal_trace_string(KER_CTX "] not found!" KER_TRACE_EOL); \
    }   \
    while (0)
#else
/* empty trace tag not found macro */
#define KER_TRACE_TAG_NOT_FOUND(tag,tag_length)
#endif /* KER_DBG(KER_DBG_LEVEL_TAG_INFO) */
#endif /* KER_TRACE_TAG_NOT_FOUND */
 
/* ***************************************************************************************** */
/*                         Use this macro to trace tag duplication                           */
/* ***************************************************************************************** */
#ifndef KER_TRACE_TAG_DUPLICATION   /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TAG_INFO))
/*#define KER_TRACE_TAG_DUPLICATION(tag,tag_length,tlv1,tlv1_length,tlv2,tlv2_length) \
    do \
    {   \
        hal_trace_string(KER_CTX "Tag [");  \
        hal_trace_buffer(KER_CTX tag, tag_length);  \
        hal_trace_string(KER_CTX "] duplication: ");    \
        hal_trace_buffer(KER_CTX tlv1, tlv1_length);    \
        hal_trace_string(KER_CTX " ");  \
        hal_trace_buffer(KER_CTX tlv2, tlv2_length);    \
        hal_trace_string(KER_CTX KER_TRACE_EOL);    \
    }   \
    while (0)
*/
#define KER_TRACE_TAG_DUPLICATION(tag,tag_length,tlv1,tlv1_length,tlv2,tlv2_length) \
    do \
    {   \
        hal_trace_string(KER_CTX "Tag [");  \
        hal_trace_buffer(KER_CTX tag, tag_length);  \
        hal_trace_string(KER_CTX "] duplication!" KER_TRACE_EOL);   \
    }   \
    while (0)
#else
/* empty trace tag not found macro */
#define KER_TRACE_TAG_DUPLICATION(tag,tag_length,tlv1,tlv1_length,tlv2,tlv2_length)
#endif /* KER_DBG(KER_DBG_LEVEL_TAG_INFO) */
#endif /* KER_TRACE_TAG_DUPLICATION */
 
 
/* ***************************************************************************************** */
/*                              Use this macro to trace APDU                                 */
/* ***************************************************************************************** */
#ifndef KER_TRACE_APDU_REQ  /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_APDU))
#define KER_TRACE_APDU_REQ(bInternal,btCase,btCLA,btINS,btP1,btP2,usLc,pbtData,usLe) \
    do \
    {   \
        hal_sprintf(KER_CTX ar_ch___InfBuffer, sizeof(ar_ch___InfBuffer), "%sRequest: <%02X><%02X><%02X><%02X><%02X> ", \
                                (bInternal)?KER_TRACE_APDU_INT_REQ_TAB:KER_TRACE_APDU_REQ_TAB,(KER_NATIVE_UINT)(btCLA),(KER_NATIVE_UINT)(btINS),(KER_NATIVE_UINT)(btP1),(KER_NATIVE_UINT)(btP2),(KER_NATIVE_UINT)(usLc));   \
        hal_trace_string(KER_CTX ar_ch___InfBuffer);    \
        if ((hal_get_trace_mode(KER_CTX_SINGLE) == KER_TRACE_MODE_SENS) || (((btCLA) == EMV_APDU_CLA_UNI) && ((btINS) == EMV_APDU_INS_SELECT)))\
            hal_trace_buffer(KER_CTX pbtData, usLc);    \
        else \
            hal_trace_string(KER_CTX "...");    \
        if (usLe != KER_EMVL1_LE_NULL)  \
            hal_sprintf(KER_CTX ar_ch___InfBuffer, sizeof(ar_ch___InfBuffer), " <%02X> [Case%u]" KER_TRACE_EOL, (KER_NATIVE_UINT)(usLe), (KER_NATIVE_UINT)(btCase)); \
        else \
            hal_sprintf(KER_CTX ar_ch___InfBuffer, sizeof(ar_ch___InfBuffer), " [Case%u]" KER_TRACE_EOL, (KER_NATIVE_UINT)(btCase)); \
        hal_trace_string(KER_CTX ar_ch___InfBuffer);    \
    }   \
    while (0)
#else
/* empty trace apdu macro */
#define KER_TRACE_APDU_REQ(bInternal,btCase,btCLA,btINS,btP1,btP2,btLc,pbtData,btLe)
#endif /* KER_DBG(KER_DBG_LEVEL_APDU) */
#endif /* KER_TRACE_APDU_REQ */
 
 
#ifndef KER_TRACE_APDU_RESP /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_APDU))
#define KER_TRACE_APDU_RESP(INTERNAL,SW1SW2,DATA,DATA_LEN) \
    do \
    {   \
        hal_sprintf(KER_CTX ar_ch___InfBuffer, sizeof(ar_ch___InfBuffer), "%sResponse: Len = %u Sw1Sw2 = <%04X> ", (INTERNAL)?KER_TRACE_APDU_INT_RESP_TAB:KER_TRACE_APDU_RESP_TAB,(KER_NATIVE_UINT)(DATA_LEN),(KER_NATIVE_UINT)(SW1SW2));   \
        hal_trace_string(KER_CTX ar_ch___InfBuffer);    \
        if (hal_get_trace_mode(KER_CTX_SINGLE) == KER_TRACE_MODE_SENS)  \
            hal_trace_buffer(KER_CTX (DATA), (DATA_LEN));   \
        hal_trace_string(KER_CTX KER_TRACE_EOL);    \
    }   \
    while (0)
#else
/* empty trace apdu macro */
#define KER_TRACE_APDU_RESP(INTERNAL,SW1SW2,DATA,DATA_LEN) 
#endif /* KER_DBG(KER_DBG_LEVEL_APDU) */
#endif /* KER_TRACE_APDU_RESP */
 
 
#ifndef KER_TRACE_NFC_APDU_RESP /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_APDU))
#define KER_TRACE_NFC_APDU_RESP(INTERNAL,SW1SW2,EXEC_TIME,DATA,DATA_LEN) \
    do \
    {   \
        hal_sprintf(KER_CTX ar_ch___InfBuffer, sizeof(ar_ch___InfBuffer), "%sResponse: Time = %lu Len = %u Sw1Sw2 = <%04X> ", \
                                (INTERNAL)?KER_TRACE_APDU_INT_RESP_TAB:KER_TRACE_APDU_RESP_TAB, (KER_NATIVE_ULONG)(EXEC_TIME), (KER_NATIVE_UINT)(DATA_LEN), (KER_NATIVE_UINT)(SW1SW2)); \
        hal_trace_string(KER_CTX ar_ch___InfBuffer);    \
        if (hal_get_trace_mode(KER_CTX_SINGLE) == KER_TRACE_MODE_SENS)  \
            hal_trace_buffer(KER_CTX (DATA), (DATA_LEN));   \
        hal_trace_string(KER_CTX KER_TRACE_EOL);    \
    }   \
    while (0)
#else
/* empty trace apdu macro */
#define KER_TRACE_NFC_APDU_RESP(INTERNAL,SW1SW2,EXEC_TIME,DATA,DATA_LEN)
#endif /* KER_DBG(KER_DBG_LEVEL_APDU) */
#endif /* KER_TRACE_NFC_APDU_RESP */
 
 
#ifndef KER_TRACE_SUPP_AIDS /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_TRACE_SUPP_APP_LIST_DEFAULT /* force to include default implementation - see hal_trace_def.c */
KER_VOID def_hal_trace_supp_app(KER_CTX_PARAM const KER_TLV* pSuppAppList);
#define KER_TRACE_SUPP_AIDS(AidList) def_hal_trace_supp_app(KER_CTX AidList);
#else
/* empty trace supp aids macro */
#define KER_TRACE_SUPP_AIDS(AidList)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_TRACE_SUPP_AIDS */
 
 
#ifndef KER_TRACE_CL    /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_TRACE_CL_DEFAULT /* force to include default implementation - see hal_trace_def.c */
KER_VOID def_hal_trace_cl(KER_CTX_PARAM const KER_TLV* pCL);
#define KER_TRACE_CL(CL) def_hal_trace_cl(KER_CTX CL);
#else
/* empty trace supp aids macro */
#define KER_TRACE_SUPP_AIDS(pAidList)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_TRACE_CL */
 
 
#ifndef KER_TRACE_TAG   /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TAG_LIST))
#define KER_TRACE_TAG_DEFAULT /* force to include default implementation - see hal_trace_def.c */
KER_VOID def_hal_trace_tag(KER_CTX_PARAM const KER_BYTE* pbtTlv, KER_INT16U usTlvLen, KER_INT16U usOrigin);
#define KER_TRACE_TAG(Tlv,TlvLen,Origin) def_hal_trace_tag(KER_CTX Tlv,TlvLen,Origin)
#else
/* empty trace tag macro */
#define KER_TRACE_TAG(TagList,Origin)
#endif /* KER_DBG(KER_DBG_LEVEL_TAG_LIST) */
#endif /* KER_TRACE_TAG */
 
 
#ifndef KER_TRACE_CVM_LIST  /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_TRACE_CVM_LIST(TranPtr, TrType, TrCurr, IccCurr, AmountX, AmountY) \
    do \
    {   \
        hal_sprintf(KER_CTX ar_ch___InfBuffer, sizeof(ar_ch___InfBuffer), "CVM List processing: TrType:%02lX Curr:%03lu/%03lu TrAmount:%lu%s CashbackAmount:%lu%s Amount X:%lu Amount Y:%lu StartPos:%lu" KER_TRACE_EOL, \
                                (KER_NATIVE_ULONG)(TrType), (KER_NATIVE_ULONG)(TrCurr), (KER_NATIVE_ULONG)(IccCurr), \
                                (KER_NATIVE_ULONG)(TranPtr->ulAmountAuthLO), (TranPtr->ulAmountAuthHI > 0)?"(!)":"", \
                                (KER_NATIVE_ULONG)(TranPtr->ulAmountOtherLO), (TranPtr->ulAmountOtherHI > 0)?"(!)":"", \
                                (KER_NATIVE_ULONG)(AmountX), (KER_NATIVE_ULONG)(AmountY), (KER_NATIVE_ULONG)((TranPtr->usCvmOffset - 8)/2));    \
        hal_trace_string(KER_CTX ar_ch___InfBuffer);    \
    }   \
    while (0)
#else
/* empty trace supp aids macro */
#define KER_TRACE_CVM_LIST(TranPtr, TrType, TrCurr, IccCurr, AmountX, AmountY)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_TRACE_CVM_LIST */
 
 
#ifndef KER_TRACE_TVR   /* If Custom trace not defined, then use default */
/* check trace level */
#if (KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT))
#define KER_TRACE_TVR_DEFAULT /* force to include default implementation - see hal_trace_def.c */
KER_VOID def_hal_trace_tvr(KER_CTX_PARAM const KER_CHAR* pchComment, const KER_BYTE* pbtTvr, KER_BYTE btTvrLen);
#define KER_TRACE_TVR(Comment,Tvr,TvrLen) def_hal_trace_tvr(KER_CTX Comment, Tvr, TvrLen)
#else
/* empty trace tvr macro */
#define KER_TRACE_TVR(Comment,Tvr,TvrLen)
#endif /* KER_DBG(KER_DBG_LEVEL_TRACE_COMMENT) */
#endif /* KER_TRACE_TVR */
 
 
/* If Custom trace not defined, then use default */
#ifndef KER_TRC_CUSTOM
 
#define KER_TRC_STD         hal_set_trace_mode(KER_CTX KER_TRACE_MODE_STD);
#define KER_TRC_SENS        hal_set_trace_mode(KER_CTX KER_TRACE_MODE_SENS);
 
#define KER_TRC_S                       hal_sprintf(KER_CTX ar_ch___InfBuffer,sizeof(ar_ch___InfBuffer),
#define KER_TRC_E           ); hal_trace_string(KER_CTX ar_ch___InfBuffer);
#define KER_TRC_NL          hal_trace_string(KER_CTX KER_TRACE_EOL);
#define KER_TRC_TIME                hal_trace_time(KER_CTX_SINGLE);
 
#endif /* KER_TRC_CUSTOM */
 
#endif /* HAL_TRACE_H */